home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Continental / Continental Gigantic.rmv next >
Encoding:
Text File  |  2001-09-27  |  50.7 KB  |  1,587 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Continental Gigantic.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Creator: Richard Bishop $
  10. // 
  11. //////////////////////////////////////////////////////////////////////
  12.  
  13. #if            NOTDEFINED(CONTINENTAL_GIGANTIC_RMV)
  14. #define        (CONTINENTAL_GIGANTIC_RMV,1)
  15.  
  16. //////////////////////////////////////////////////////////////////////
  17. // Definitions we are required to define for Continental Maps
  18. //////////////////////////////////////////////////////////////////////
  19.  
  20. //////////////////////////////////////////////////////////////////////
  21. // Secondary Resource Placements
  22.  
  23. #if DEFINED(kWinterMap)
  24.   PlaceWorldUnitInRing (Res-Walrus, 12, 12)
  25.   PlaceWorldUnitInRing (Res-Walrus, 12, 12)
  26. #else 
  27.   PlaceWorldUnitInRing (Res-Hippopotamus, 12, 12)
  28.   PlaceWorldUnitInRing (Res-Hippopotamus, 12, 12)
  29. #endif
  30.  
  31. //////////////////////////////////////////////////////////////////////
  32. // Resource Limitations
  33. ResourcePlacementLimit (Gold,         8,    9)
  34. ResourcePlacementLimit (Steel,         7,     8)
  35. ResourcePlacementLimit (Berry,         6,    7)
  36. ResourcePlacementLimit (Tree,         3,    5)
  37. ResourcePlacementLimit (Stone,         11,    12)
  38.  
  39. PlaceResourceInRing (Gold, 26, 27)
  40. PlaceResourceInRing (Iron, 26, 27)
  41.  
  42. #if Is2Players
  43. //////////////////////////////////////////////////////////////////////
  44. // 2 PLAYERS...
  45. //////////////////////////////////////////////////////////////////////
  46.  
  47. ResourceSeperation    7
  48.  
  49. PlaceResourceInRing (Berry, 28, 34)
  50. PlaceResourceInRing (Gold, 40, 45)
  51. PlaceResourceInRing (Iron, 40, 45)
  52. PlaceResourceInRing (Berry, 60, 65)
  53. PlaceResourceInRing (Stone, 60, 65) 
  54.  
  55. //////////////////////////////////////////////////////////////////////
  56. // terrain definitions
  57. HeightMapSmoothness                    0)
  58. #define        (kMinIntElevation,            -8)
  59. #define        (kMaxIntElevation,            8)
  60. #define        (kElevationScale,                0.5)
  61. #define        (kPercentLand,                Between(.76, .76))
  62. #define        (kWaterBorder,                17)
  63. #define        (kHeightMapChaos,                Between(15, 15))
  64.                                             
  65. #define        (kMinimumStartPositionToMapEdge        1)
  66. #define        (kOuterPushFromMapCenter        34)
  67. #define        (kInnerPushFromMapCenter         0)
  68.  
  69. //////////////////////////////////////////////////////////////////////
  70. // player definitions
  71. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  72. #define        (kPlayerInnerRadius,            0.75)
  73. #define        (kPlayerOuterRadius,            0.85)
  74. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  75. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  76. #define        (kPlayerLandChaos,            0.8)
  77. #define        (kPlayerLandClumps,            1)
  78. #define        (kPlayerFlatChaos,            0.8)
  79. #define        (kPlayerFlatClumps,            2)
  80. #define        (kPlayerTreePercentage,            0.04)
  81.  
  82.  
  83. //////////////////////////////////////////////////////////////////////
  84. // inner neutral definitions
  85. #define        (kNeutralInnerRadius,            0.05)
  86. #define        (kNeutralOuterRadius,            0.5)
  87. #define        (kNeutralOptimalFactor,            0.7)
  88. #define        (kNumInnerNeutrals,            Between(25, 25))
  89. #define        (kInnerNeutralPercentLand,        0.3)
  90. #define        (kInnerNeutralPercentFlat,        0.5)
  91. #define        (kInnerNeutralTreePercentage,          0.1)
  92. #define        (kInnerNeutralLandChaos,        0.9)
  93. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  94. #define        (kInnerNeutralFlatChaos,        0.8)
  95. #define        (kInnerNeutralFlatClumps,        1)
  96.  
  97.  
  98. //////////////////////////////////////////////////////////////////////
  99. // outer neutral definitions
  100. #define        (kNumOuterNeutrals,            15)
  101. #define        (kOuterNeutralPercentLand,        0.35)
  102. #define        (kOuterNeutralPercentFlat,        0.5)
  103. #define        (kOuterNeutralTreePercentage,          0.1)
  104. #define        (kOuterNeutralLandChaos,        0.8)
  105. #define        (kOuterNeutralLandClumps,        2)
  106. #define        (kOuterNeutralFlatChaos,        0.8)
  107. #define        (kOuterNeutralFlatClumps,        1)
  108.  
  109.  
  110. //////////////////////////////////////////////////////////////////////
  111. // resource definitions
  112. #define        (kMaxResourceElevation,            2)
  113. #define        (kResourceToEdgeDistance,        1)
  114. #define        (kResourceToWaterDistance,        1)
  115.  
  116. #define        (kAnimalPerPlayer,            0)
  117. #define        (kAnimalPerNeutral,            0)
  118.  
  119. #if (IsPaleoEpoch) 
  120.   #define  (kBerryPerPlayer,    2)
  121. #else
  122.   #define  (kBerryPerPlayer,    1)
  123. #endif
  124.  
  125. #define        (kBerryPerNeutral,                2)
  126.  
  127. #define        (kFishPerPlayer,                5)
  128. #define        (kFishPerNeutral,                60)
  129.  
  130. #define        (kGoldPerPlayer,                1)
  131. #define        (kGoldPerNeutral,                7)
  132.  
  133. #define        (kOilPerPlayer,                    0)
  134. #define        (kOilPerNeutral,                0)
  135.  
  136. #define        (kSteelPerPlayer,                1)
  137. #define        (kSteelPerNeutral,                7)
  138.  
  139. #define        (kStonePerPlayer,                1)
  140. #define        (kStonePerNeutral,                2)
  141.  
  142. #define        (kTreePerPlayer,                between(2,3))
  143. #define        (kTreePerNeutral,                0)
  144.  
  145.  
  146. //////////////////////////////////////////////////////////////////////
  147. // forest definitions
  148. #define        (kForestFreeRadius,            7.0)
  149. #define        (kForestsPerPlayer,            1)
  150. #define        (kForestChaosLevel,            0.1)
  151. #define        (kMaxClumpsPerForest,              2)
  152.  
  153.  
  154. #elif Is3Players
  155. //////////////////////////////////////////////////////////////////////
  156. // 3 PLAYERS...
  157. //////////////////////////////////////////////////////////////////////
  158.  
  159. PlaceResourceInRing (Gold, 52, 57)
  160. PlaceResourceInRing (Iron, 50, 55)
  161. PlaceResourceInRing (Stone, 45, 49)
  162. PlaceResourceInRing (Berry, 28, 34)
  163.  
  164. ResourceSeperation    7
  165.  
  166. //////////////////////////////////////////////////////////////////////
  167. // terrain definitions
  168. HeightMapSmoothness                    0)
  169. #define        (kMinIntElevation,            -8)
  170. #define        (kMaxIntElevation,            8)
  171. #define        (kElevationScale,                0.5)
  172. #define        (kPercentLand,                Between(.76, .76))
  173. #define        (kWaterBorder,                17)
  174. #define        (kHeightMapChaos,                Between(15, 15))
  175.                                             
  176. #define        (kMinimumStartPositionToMapEdge        1)
  177. #define        (kOuterPushFromMapCenter        28)
  178. #define        (kInnerPushFromMapCenter         0)
  179.  
  180. //////////////////////////////////////////////////////////////////////
  181. // player definitions
  182. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  183. #define        (kPlayerInnerRadius,            0.75)
  184. #define        (kPlayerOuterRadius,            0.85)
  185. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  186. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  187. #define        (kPlayerLandChaos,            0.8)
  188. #define        (kPlayerLandClumps,            1)
  189. #define        (kPlayerFlatChaos,            0.8)
  190. #define        (kPlayerFlatClumps,            2)
  191. #define        (kPlayerTreePercentage,            0.04)
  192.  
  193.  
  194. //////////////////////////////////////////////////////////////////////
  195. // inner neutral definitions
  196. #define        (kNeutralInnerRadius,            0.03)
  197. #define        (kNeutralOuterRadius,            0.5)
  198. #define        (kNeutralOptimalFactor,            0.7)
  199. #define        (kNumInnerNeutrals,            Between(25, 25))
  200. #define        (kInnerNeutralPercentLand,        0.25)
  201. #define        (kInnerNeutralPercentFlat,        0.5)
  202. #define        (kInnerNeutralTreePercentage,              0.08)
  203. #define        (kInnerNeutralLandChaos,        0.9)
  204. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  205. #define        (kInnerNeutralFlatChaos,        0.8)
  206. #define        (kInnerNeutralFlatClumps,        1)
  207.  
  208.  
  209. //////////////////////////////////////////////////////////////////////
  210. // outer neutral definitions
  211. #define        (kNumOuterNeutrals,            15)
  212. #define        (kOuterNeutralPercentLand,        0.35)
  213. #define        (kOuterNeutralPercentFlat,        0.5)
  214. #define        (kOuterNeutralTreePercentage,          0.1)
  215. #define        (kOuterNeutralLandChaos,        0.8)
  216. #define        (kOuterNeutralLandClumps,        2)
  217. #define        (kOuterNeutralFlatChaos,        0.8)
  218. #define        (kOuterNeutralFlatClumps,        1)
  219.  
  220.  
  221. //////////////////////////////////////////////////////////////////////
  222. // resource definitions
  223. #define        (kMaxResourceElevation,            2)
  224. #define        (kResourceToEdgeDistance,        1)
  225. #define        (kResourceToWaterDistance,        1)
  226.  
  227. #define        (kAnimalPerPlayer,            0)
  228. #define        (kAnimalPerNeutral,            0)
  229.  
  230. #if (IsPaleoEpoch) 
  231.   #define  (kBerryPerPlayer,    2)
  232. #else
  233.   #define  (kBerryPerPlayer,    1)
  234. #endif
  235.  
  236. #define        (kBerryPerNeutral,                3)
  237.  
  238. #define        (kFishPerPlayer,                5)
  239. #define        (kFishPerNeutral,                60)
  240.  
  241. #define        (kGoldPerPlayer,                1)
  242. #define        (kGoldPerNeutral,                8)
  243.  
  244. #define        (kOilPerPlayer,                    0)
  245. #define        (kOilPerNeutral,                0)
  246.  
  247. #define        (kSteelPerPlayer,                1)
  248. #define        (kSteelPerNeutral,                8)
  249.  
  250. #define        (kStonePerPlayer,                1)
  251. #define        (kStonePerNeutral,                1)
  252.  
  253. #define        (kTreePerPlayer,                between(2,3))
  254. #define        (kTreePerNeutral,                0)
  255.  
  256.  
  257. //////////////////////////////////////////////////////////////////////
  258. // forest definitions
  259. #define        (kForestFreeRadius,            7.0)
  260. #define        (kForestsPerPlayer,            1)
  261. #define        (kForestChaosLevel,            0.1)
  262. #define        (kMaxClumpsPerForest,              2)
  263.  
  264. #elif Is4Players
  265. //////////////////////////////////////////////////////////////////////
  266. // 4 PLAYERS...
  267. //////////////////////////////////////////////////////////////////////
  268.  
  269. ResourceSeperation    7
  270.  
  271. PlaceResourceInRing (Gold, 42, 48)
  272. PlaceResourceInRing (Iron, 42, 48)
  273. PlaceResourceInRing (Berry, 40, 48)
  274. PlaceResourceInRing (Stone, 28, 34)
  275.  
  276. //////////////////////////////////////////////////////////////////////
  277. // terrain definitions
  278. HeightMapSmoothness                    0)
  279. #define        (kMinIntElevation,            -8)
  280. #define        (kMaxIntElevation,            8)
  281. #define        (kElevationScale,                0.5)
  282. #define        (kPercentLand,                Between(.76, .76))
  283. #define        (kWaterBorder,                17)
  284. #define        (kHeightMapChaos,                Between(15, 15))
  285.                                             
  286. #define        (kMinimumStartPositionToMapEdge        1)
  287. #define        (kOuterPushFromMapCenter        28)
  288. #define        (kInnerPushFromMapCenter         0)
  289.  
  290. //////////////////////////////////////////////////////////////////////
  291. // player definitions
  292. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  293. #define        (kPlayerInnerRadius,            0.75)
  294. #define        (kPlayerOuterRadius,            0.85)
  295. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  296. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  297. #define        (kPlayerLandChaos,            0.8)
  298. #define        (kPlayerLandClumps,            1)
  299. #define        (kPlayerFlatChaos,            0.8)
  300. #define        (kPlayerFlatClumps,            2)
  301. #define        (kPlayerTreePercentage,            0.04)
  302.  
  303. //////////////////////////////////////////////////////////////////////
  304. // inner neutral definitions
  305. #define        (kNeutralInnerRadius,            0.05)
  306. #define        (kNeutralOuterRadius,            0.45)
  307. #define        (kNeutralOptimalFactor,            0.7)
  308. #define        (kNumInnerNeutrals,            Between(25, 25))
  309. #define        (kInnerNeutralPercentLand,        0.3)
  310. #define        (kInnerNeutralPercentFlat,        0.5)
  311. #define        (kInnerNeutralTreePercentage,            0.1)
  312. #define        (kInnerNeutralLandChaos,        0.9)
  313. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  314. #define        (kInnerNeutralFlatChaos,        0.8)
  315. #define        (kInnerNeutralFlatClumps,        1)
  316.  
  317. //////////////////////////////////////////////////////////////////////
  318. // outer neutral definitions
  319. #define        (kNumOuterNeutrals,            15)
  320. #define        (kOuterNeutralPercentLand,        0.25)
  321. #define        (kOuterNeutralPercentFlat,        0.5)
  322. #define        (kOuterNeutralTreePercentage,          0.1)
  323. #define        (kOuterNeutralLandChaos,        0.8)
  324. #define        (kOuterNeutralLandClumps,        2)
  325. #define        (kOuterNeutralFlatChaos,        0.8)
  326. #define        (kOuterNeutralFlatClumps,        1)
  327.  
  328. //////////////////////////////////////////////////////////////////////
  329. // resource definitions
  330. #define        (kMaxResourceElevation,            2)
  331. #define        (kResourceToEdgeDistance,        1)
  332. #define        (kResourceToWaterDistance,        1)
  333.  
  334. #define        (kAnimalPerPlayer,            0)
  335. #define        (kAnimalPerNeutral,            0)
  336.  
  337. #if (IsPaleoEpoch) 
  338.   #define  (kBerryPerPlayer,    2)
  339. #else
  340.   #define  (kBerryPerPlayer,    1)
  341. #endif
  342.  
  343. #define        (kBerryPerNeutral,                2)
  344.  
  345. #define        (kFishPerPlayer,                5)
  346. #define        (kFishPerNeutral,                60)
  347.  
  348. #define        (kGoldPerPlayer,                1)
  349. #define        (kGoldPerNeutral,                8)
  350.  
  351. #define        (kOilPerPlayer,                    0)
  352. #define        (kOilPerNeutral,                0)
  353.  
  354. #define        (kSteelPerPlayer,                1)
  355. #define        (kSteelPerNeutral,                8)
  356.  
  357. #define        (kStonePerPlayer,                1)
  358. #define        (kStonePerNeutral,                3)
  359.  
  360. #define        (kTreePerPlayer,                between(2,3))
  361. #define        (kTreePerNeutral,                0)
  362.  
  363. //////////////////////////////////////////////////////////////////////
  364. // forest definitions
  365. #define        (kForestFreeRadius,            7.0)
  366. #define        (kForestsPerPlayer,            2)
  367. #define        (kForestChaosLevel,            0.1)
  368. #define        (kMaxClumpsPerForest,              2)
  369.  
  370. #elif Is5Players
  371. //////////////////////////////////////////////////////////////////////
  372. // 5 PLAYERS...
  373. //////////////////////////////////////////////////////////////////////
  374.  
  375. ResourceSeperation    6
  376.  
  377. PlaceResourceInRing (Gold, 42, 48)
  378. PlaceResourceInRing (Iron, 42, 48)
  379. PlaceResourceInRing (Berry, 40, 48)
  380. PlaceResourceInRing (Stone, 35, 45)
  381.  
  382. //////////////////////////////////////////////////////////////////////
  383. // terrain definitions
  384. HeightMapSmoothness                    0)
  385. #define        (kMinIntElevation,            -8)
  386. #define        (kMaxIntElevation,            8)
  387. #define        (kElevationScale,                0.5)
  388. #define        (kPercentLand,                Between(.76, .76))
  389. #define        (kWaterBorder,                17)
  390. #define        (kHeightMapChaos,                Between(15, 15))
  391.                                             
  392. #define        (kMinimumStartPositionToMapEdge        1)
  393. #define        (kOuterPushFromMapCenter        28)
  394. #define        (kInnerPushFromMapCenter         0)
  395.  
  396. //////////////////////////////////////////////////////////////////////
  397. // player definitions
  398. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  399. #define        (kPlayerInnerRadius,            0.75)
  400. #define        (kPlayerOuterRadius,            0.85)
  401. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  402. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  403. #define        (kPlayerLandChaos,            0.8)
  404. #define        (kPlayerLandClumps,            1)
  405. #define        (kPlayerFlatChaos,            0.8)
  406. #define        (kPlayerFlatClumps,            2)
  407. #define        (kPlayerTreePercentage,            0.1)
  408.  
  409.  
  410. //////////////////////////////////////////////////////////////////////
  411. // inner neutral definitions
  412. #define        (kNeutralInnerRadius,            0.05)
  413. #define        (kNeutralOuterRadius,            0.45)
  414. #define        (kNeutralOptimalFactor,            0.7)
  415. #define        (kNumInnerNeutrals,            Between(25, 25))
  416. #define        (kInnerNeutralPercentLand,        0.3)
  417. #define        (kInnerNeutralPercentFlat,        0.5)
  418. #define        (kInnerNeutralTreePercentage,          0.1)
  419. #define        (kInnerNeutralLandChaos,        0.9)
  420. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  421. #define        (kInnerNeutralFlatChaos,        0.8)
  422. #define        (kInnerNeutralFlatClumps,        1)
  423.  
  424.  
  425. //////////////////////////////////////////////////////////////////////
  426. // outer neutral definitions
  427. #define        (kNumOuterNeutrals,            15)
  428. #define        (kOuterNeutralPercentLand,        0.45)
  429. #define        (kOuterNeutralPercentFlat,        0.6)
  430. #define        (kOuterNeutralTreePercentage,          0.1)
  431. #define        (kOuterNeutralLandChaos,        0.8)
  432. #define        (kOuterNeutralLandClumps,        2)
  433. #define        (kOuterNeutralFlatChaos,        0.8)
  434. #define        (kOuterNeutralFlatClumps,        1)
  435.  
  436.  
  437. //////////////////////////////////////////////////////////////////////
  438. // resource definitions
  439. #define        (kMaxResourceElevation,            2)
  440. #define        (kResourceToEdgeDistance,        1)
  441. #define        (kResourceToWaterDistance,        1)
  442.  
  443. #define        (kAnimalPerPlayer,            0)
  444. #define        (kAnimalPerNeutral,            0)
  445.  
  446. #if (IsPaleoEpoch) 
  447.   #define  (kBerryPerPlayer,    2)
  448. #else
  449.   #define  (kBerryPerPlayer,    1)
  450. #endif
  451.  
  452. #define        (kBerryPerNeutral,                2)
  453.  
  454. #define        (kFishPerPlayer,                5)
  455. #define        (kFishPerNeutral,                60)
  456.  
  457. #define        (kGoldPerPlayer,                1)
  458. #define        (kGoldPerNeutral,                8)
  459.  
  460. #define        (kOilPerPlayer,                    0)
  461. #define        (kOilPerNeutral,                0)
  462.  
  463. #define        (kSteelPerPlayer,                1)
  464. #define        (kSteelPerNeutral,                8)
  465.  
  466. #define        (kStonePerPlayer,                1)
  467. #define        (kStonePerNeutral,                2)
  468.  
  469. #define        (kTreePerPlayer,                between(2,3))
  470. #define        (kTreePerNeutral,                0)
  471.  
  472.  
  473. //////////////////////////////////////////////////////////////////////
  474. // forest definitions
  475. #define        (kForestFreeRadius,            7.0)
  476. #define        (kForestsPerPlayer,            1)
  477. #define        (kForestChaosLevel,            0.1)
  478. #define        (kMaxClumpsPerForest,              2)
  479.  
  480. #elif Is6Players
  481. //////////////////////////////////////////////////////////////////////
  482. // 6 PLAYERS...
  483. //////////////////////////////////////////////////////////////////////
  484.  
  485. ResourceSeperation    6
  486.  
  487. PlaceResourceInRing (Gold, 26, 29)
  488. PlaceResourceInRing (Iron, 26, 29)
  489. PlaceResourceInRing (Berry, 40, 48)
  490. PlaceResourceInRing (Stone, 28, 34)
  491.  
  492. //////////////////////////////////////////////////////////////////////
  493. // terrain definitions
  494. HeightMapSmoothness                    0)
  495. #define        (kMinIntElevation,            -8)
  496. #define        (kMaxIntElevation,            8)
  497. #define        (kElevationScale,                0.5)
  498. #define        (kPercentLand,                Between(.76, .76))
  499. #define        (kWaterBorder,                17)
  500. #define        (kHeightMapChaos,                Between(15, 15))
  501.                                             
  502. #define        (kMinimumStartPositionToMapEdge        1)
  503. #define        (kOuterPushFromMapCenter        28)
  504. #define        (kInnerPushFromMapCenter         0)
  505.  
  506. //////////////////////////////////////////////////////////////////////
  507. // player definitions
  508. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  509. #define        (kPlayerInnerRadius,            0.75)
  510. #define        (kPlayerOuterRadius,            0.85)
  511. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  512. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  513. #define        (kPlayerLandChaos,            0.8)
  514. #define        (kPlayerLandClumps,            1)
  515. #define        (kPlayerFlatChaos,            0.8)
  516. #define        (kPlayerFlatClumps,            2)
  517. #define        (kPlayerTreePercentage,            0.04)
  518.  
  519. //////////////////////////////////////////////////////////////////////
  520. // inner neutral definitions
  521. #define        (kNeutralInnerRadius,            0.05)
  522. #define        (kNeutralOuterRadius,            0.45)
  523. #define        (kNeutralOptimalFactor,            0.7)
  524. #define        (kNumInnerNeutrals,            Between(25, 25))
  525. #define        (kInnerNeutralPercentLand,        0.3)
  526. #define        (kInnerNeutralPercentFlat,        0.5)
  527. #define        (kInnerNeutralTreePercentage,          0.1)
  528. #define        (kInnerNeutralLandChaos,        0.9)
  529. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  530. #define        (kInnerNeutralFlatChaos,        0.8)
  531. #define        (kInnerNeutralFlatClumps,        1)
  532.  
  533. //////////////////////////////////////////////////////////////////////
  534. // outer neutral definitions
  535. #define        (kNumOuterNeutrals,            15)
  536. #define        (kOuterNeutralPercentLand,        0.25)
  537. #define        (kOuterNeutralPercentFlat,        0.6)
  538. #define        (kOuterNeutralTreePercentage,          0.1)
  539. #define        (kOuterNeutralLandChaos,        0.8)
  540. #define        (kOuterNeutralLandClumps,        2)
  541. #define        (kOuterNeutralFlatChaos,        0.8)
  542. #define        (kOuterNeutralFlatClumps,        1)
  543.  
  544. //////////////////////////////////////////////////////////////////////
  545. // resource definitions
  546. #define        (kMaxResourceElevation,            2)
  547. #define        (kResourceToEdgeDistance,        1)
  548. #define        (kResourceToWaterDistance,        1)
  549.  
  550. #define        (kAnimalPerPlayer,            0)
  551. #define        (kAnimalPerNeutral,            0)
  552.  
  553. #if (IsPaleoEpoch) 
  554.   #define  (kBerryPerPlayer,    2)
  555. #else
  556.   #define  (kBerryPerPlayer,    1)
  557. #endif
  558.  
  559. #define        (kBerryPerNeutral,                2)
  560.  
  561. #define        (kFishPerPlayer,                5)
  562. #define        (kFishPerNeutral,                60)
  563.  
  564. #define        (kGoldPerPlayer,                1)
  565. #define        (kGoldPerNeutral,                8)
  566.  
  567. #define        (kOilPerPlayer,                    0)
  568. #define        (kOilPerNeutral,                0)
  569.  
  570. #define        (kSteelPerPlayer,                1)
  571. #define        (kSteelPerNeutral,                8)
  572.  
  573. #define        (kStonePerPlayer,                1)
  574. #define        (kStonePerNeutral,                2)
  575.  
  576. #define        (kTreePerPlayer,                between(2,3))
  577. #define        (kTreePerNeutral,                0)
  578.  
  579.  
  580. //////////////////////////////////////////////////////////////////////
  581. // forest definitions
  582. #define        (kForestFreeRadius,            7.0)
  583. #define        (kForestsPerPlayer,            1)
  584. #define        (kForestChaosLevel,            0.1)
  585. #define        (kMaxClumpsPerForest,              2)
  586.  
  587. #elif Is7Players
  588. //////////////////////////////////////////////////////////////////////
  589. // 7 PLAYERS...
  590. //////////////////////////////////////////////////////////////////////
  591.  
  592. ResourceSeperation    6
  593.  
  594. PlaceResourceInRing (Gold, 28, 32)
  595. PlaceResourceInRing (Iron, 28, 32)
  596. PlaceResourceInRing (Stone, 28, 34)
  597.  
  598. //////////////////////////////////////////////////////////////////////
  599. // terrain definitions
  600. HeightMapSmoothness                    0)
  601. #define        (kMinIntElevation,            -8)
  602. #define        (kMaxIntElevation,            8)
  603. #define        (kElevationScale,                0.5)
  604. #define        (kPercentLand,                Between(.76, .76))
  605. #define        (kWaterBorder,                17)
  606. #define        (kHeightMapChaos,                Between(15, 15))
  607.                                             
  608. #define        (kMinimumStartPositionToMapEdge        1)
  609. #define        (kOuterPushFromMapCenter        28)
  610. #define        (kInnerPushFromMapCenter         0)
  611.  
  612. //////////////////////////////////////////////////////////////////////
  613. // player definitions
  614. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  615. #define        (kPlayerInnerRadius,            0.75)
  616. #define        (kPlayerOuterRadius,            0.85)
  617. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  618. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  619. #define        (kPlayerLandChaos,            0.8)
  620. #define        (kPlayerLandClumps,            1)
  621. #define        (kPlayerFlatChaos,            0.8)
  622. #define        (kPlayerFlatClumps,            2)
  623. #define        (kPlayerTreePercentage,            0.04)
  624.  
  625.  
  626. //////////////////////////////////////////////////////////////////////
  627. // inner neutral definitions
  628. #define        (kNeutralInnerRadius,            0.05)
  629. #define        (kNeutralOuterRadius,            0.50)
  630. #define        (kNeutralOptimalFactor,            0.7)
  631. #define        (kNumInnerNeutrals,            Between(25, 25))
  632. #define        (kInnerNeutralPercentLand,        0.3)
  633. #define        (kInnerNeutralPercentFlat,        0.5)
  634. #define        (kInnerNeutralTreePercentage,          0.1)
  635. #define        (kInnerNeutralLandChaos,        0.9)
  636. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  637. #define        (kInnerNeutralFlatChaos,        0.8)
  638. #define        (kInnerNeutralFlatClumps,        1)
  639.  
  640.  
  641. //////////////////////////////////////////////////////////////////////
  642. // outer neutral definitions
  643. #define        (kNumOuterNeutrals,            15)
  644. #define        (kOuterNeutralPercentLand,        0.25)
  645. #define        (kOuterNeutralPercentFlat,        0.6)
  646. #define        (kOuterNeutralTreePercentage,          0.1)
  647. #define        (kOuterNeutralLandChaos,        0.8)
  648. #define        (kOuterNeutralLandClumps,        2)
  649. #define        (kOuterNeutralFlatChaos,        0.8)
  650. #define        (kOuterNeutralFlatClumps,        1)
  651.  
  652.  
  653. //////////////////////////////////////////////////////////////////////
  654. // resource definitions
  655. #define        (kMaxResourceElevation,            2)
  656. #define        (kResourceToEdgeDistance,        1)
  657. #define        (kResourceToWaterDistance,        1)
  658.  
  659. #define        (kAnimalPerPlayer,            0)
  660. #define        (kAnimalPerNeutral,            0)
  661.  
  662. #if (IsPaleoEpoch) 
  663.   #define  (kBerryPerPlayer,    2)
  664. #else
  665.   #define  (kBerryPerPlayer,    1)
  666. #endif
  667.  
  668. #define        (kBerryPerNeutral,                2)
  669.  
  670. #define        (kFishPerPlayer,                5)
  671. #define        (kFishPerNeutral,                60)
  672.  
  673. #define        (kGoldPerPlayer,                1)
  674. #define        (kGoldPerNeutral,                9)
  675.  
  676. #define        (kOilPerPlayer,                    0)
  677. #define        (kOilPerNeutral,                0)
  678.  
  679. #define        (kSteelPerPlayer,                1)
  680. #define        (kSteelPerNeutral,                9)
  681.  
  682. #define        (kStonePerPlayer,                1)
  683. #define        (kStonePerNeutral,                2)
  684.  
  685. #define        (kTreePerPlayer,                between(2,3))
  686. #define        (kTreePerNeutral,                0)
  687.  
  688.  
  689. //////////////////////////////////////////////////////////////////////
  690. // forest definitions
  691. #define        (kForestFreeRadius,            7.0)
  692. #define        (kForestsPerPlayer,            1)
  693. #define        (kForestChaosLevel,            0.1)
  694. #define        (kMaxClumpsPerForest,              2)
  695. #elif Is8Players
  696.  
  697. //////////////////////////////////////////////////////////////////////
  698. // 8 PLAYERS...
  699. //////////////////////////////////////////////////////////////////////
  700.  
  701. ResourceSeperation    6
  702.  
  703. PlaceResourceInRing (Gold, 26, 27)
  704. PlaceResourceInRing (Iron, 26, 27)
  705. PlaceResourceInRing (Stone, 28, 34)
  706.  
  707. //////////////////////////////////////////////////////////////////////
  708. // terrain definitions
  709. HeightMapSmoothness                    0)
  710. #define        (kMinIntElevation,            -8)
  711. #define        (kMaxIntElevation,            8)
  712. #define        (kElevationScale,                0.5)
  713. #define        (kPercentLand,                Between(.76, .76))
  714. #define        (kWaterBorder,                17)
  715. #define        (kHeightMapChaos,                Between(15, 15))
  716.                                             
  717. #define        (kMinimumStartPositionToMapEdge        1)
  718. #define        (kOuterPushFromMapCenter        28)
  719. #define        (kInnerPushFromMapCenter         0)
  720.  
  721. //////////////////////////////////////////////////////////////////////
  722. // player definitions
  723. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  724. #define        (kPlayerInnerRadius,            0.75)
  725. #define        (kPlayerOuterRadius,            0.85)
  726. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  727. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  728. #define        (kPlayerLandChaos,            0.8)
  729. #define        (kPlayerLandClumps,            1)
  730. #define        (kPlayerFlatChaos,            0.8)
  731. #define        (kPlayerFlatClumps,            2)
  732. #define        (kPlayerTreePercentage,            0.04)
  733.  
  734.  
  735. //////////////////////////////////////////////////////////////////////
  736. // inner neutral definitions
  737. #define        (kNeutralInnerRadius,            0.05)
  738. #define        (kNeutralOuterRadius,            0.50)
  739. #define        (kNeutralOptimalFactor,            0.7)
  740. #define        (kNumInnerNeutrals,            Between(25, 25))
  741. #define        (kInnerNeutralPercentLand,        0.3)
  742. #define        (kInnerNeutralPercentFlat,        0.5)
  743. #define        (kInnerNeutralTreePercentage,          0.1)
  744. #define        (kInnerNeutralLandChaos,        0.9)
  745. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  746. #define        (kInnerNeutralFlatChaos,        0.8)
  747. #define        (kInnerNeutralFlatClumps,        1)
  748.  
  749.  
  750. //////////////////////////////////////////////////////////////////////
  751. // outer neutral definitions
  752. #define        (kNumOuterNeutrals,            15)
  753. #define        (kOuterNeutralPercentLand,        0.25)
  754. #define        (kOuterNeutralPercentFlat,        0.6)
  755. #define        (kOuterNeutralTreePercentage,          0.1)
  756. #define        (kOuterNeutralLandChaos,        0.8)
  757. #define        (kOuterNeutralLandClumps,        2)
  758. #define        (kOuterNeutralFlatChaos,        0.8)
  759. #define        (kOuterNeutralFlatClumps,        1)
  760.  
  761.  
  762.  
  763. //////////////////////////////////////////////////////////////////////
  764. // resource definitions
  765. #define        (kMaxResourceElevation,            2)
  766. #define        (kResourceToEdgeDistance,        1)
  767. #define        (kResourceToWaterDistance,        1)
  768.  
  769. #define        (kAnimalPerPlayer,            0)
  770. #define        (kAnimalPerNeutral,            0)
  771.  
  772. #if (IsPaleoEpoch) 
  773.   #define  (kBerryPerPlayer,    2)
  774. #else
  775.   #define  (kBerryPerPlayer,    1)
  776. #endif
  777.  
  778. #define        (kBerryPerNeutral,                2)
  779.  
  780. #define        (kFishPerPlayer,                5)
  781. #define        (kFishPerNeutral,                60)
  782.  
  783. #define        (kGoldPerPlayer,                1)
  784. #define        (kGoldPerNeutral,                9)
  785.  
  786. #define        (kOilPerPlayer,                    0)
  787. #define        (kOilPerNeutral,                0)
  788.  
  789. #define        (kSteelPerPlayer,                1)
  790. #define        (kSteelPerNeutral,                9)
  791.  
  792. #define        (kStonePerPlayer,                1)
  793. #define        (kStonePerNeutral,                3)
  794.  
  795. #define        (kTreePerPlayer,                between(2,3))
  796. #define        (kTreePerNeutral,                0)
  797.  
  798.  
  799. //////////////////////////////////////////////////////////////////////
  800. // forest definitions
  801. #define        (kForestFreeRadius,            7.0)
  802. #define        (kForestsPerPlayer,            1)
  803. #define        (kForestChaosLevel,            0.1)
  804. #define        (kMaxClumpsPerForest,              2)
  805.  
  806. #elif Is9Players
  807. //////////////////////////////////////////////////////////////////////
  808. // 9 PLAYERS...
  809. //////////////////////////////////////////////////////////////////////
  810.  
  811. //////////////////////////////////////////////////////////////////////
  812. // terrain definitions
  813. #define        (kMinIntElevation,            -10)
  814. #define        (kMaxIntElevation,            10)
  815. #define        (kElevationScale,                0.99)
  816. #define        (kPercentLand,                Between(.84, .84))
  817. #define        (kWaterBorder,                0)
  818. #define        (kHeightMapChaos,                Between(8, 20))
  819.  
  820. #define        (kMinimumStartPositionToMapEdge    4)
  821. #define        (kOuterPushFromMapCenter        28)
  822. #define        (kInnerPushFromMapCenter         0)                                            
  823. //////////////////////////////////////////////////////////////////////
  824. // player definitions
  825. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  826. #define        (kPlayerInnerRadius,            0.7)
  827. #define        (kPlayerOuterRadius,            0.99)
  828. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  829. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  830. #define        (kPlayerLandChaos,            0.8)
  831. #define        (kPlayerLandClumps,            1)
  832. #define        (kPlayerFlatChaos,            0.8)
  833. #define        (kPlayerFlatClumps,            2)
  834. #define        (kPlayerTreePercentage,            0.1)
  835.  
  836.  
  837. //////////////////////////////////////////////////////////////////////
  838. // inner neutral definitions
  839. #define        (kNeutralInnerRadius,            0.45)
  840. #define        (kNeutralOuterRadius,            0.45)
  841. #define        (kNeutralOptimalFactor,            0.7)
  842. #define        (kNumInnerNeutrals,            Between(3, 3))
  843. #define        (kInnerNeutralPercentLand,        0.1)
  844. #define        (kInnerNeutralPercentFlat,        0.8)
  845. #define        (kInnerNeutralTreePercentage,          0.2)
  846. #define        (kInnerNeutralLandChaos,        0.9)
  847. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  848. #define        (kInnerNeutralFlatChaos,        0.8)
  849. #define        (kInnerNeutralFlatClumps,        1)
  850.  
  851.  
  852. //////////////////////////////////////////////////////////////////////
  853. // outer neutral definitions
  854. #define        (kNumOuterNeutrals,            22)
  855. #define        (kOuterNeutralPercentLand,        0.45)
  856. #define        (kOuterNeutralPercentFlat,        0.8)
  857. #define        (kOuterNeutralTreePercentage,          0.2)
  858. #define        (kOuterNeutralLandChaos,        0.8)
  859. #define        (kOuterNeutralLandClumps,        2)
  860. #define        (kOuterNeutralFlatChaos,        0.8)
  861. #define        (kOuterNeutralFlatClumps,        1)
  862.  
  863.  
  864. //////////////////////////////////////////////////////////////////////
  865. // resource definitions
  866. #define        (kMaxResourceElevation,            3)
  867. #define        (kResourceToEdgeDistance,        1)
  868. #define        (kResourceToWaterDistance,        1)
  869.  
  870. #define        (kAnimalPerPlayer,            0)
  871. #define        (kAnimalPerNeutral,            0)
  872.  
  873. #define        (kBerryPerPlayer,                1)
  874. #define        (kBerryPerNeutral,            0)
  875.  
  876. #define        (kFishPerPlayer,                0)
  877. #define        (kFishPerNeutral,                45)
  878.  
  879. #define        (kGoldPerPlayer,                2)
  880. #define        (kGoldPerNeutral,                0)
  881.  
  882. #define        (kOilPerPlayer,                0)
  883. #define        (kOilPerNeutral,                0)
  884.  
  885. #define        (kSteelPerPlayer,                2)
  886. #define        (kSteelPerNeutral,            0)
  887.  
  888. #define        (kStonePerPlayer,                1)
  889. #define        (kStonePerNeutral,            5)
  890.  
  891. #define        (kTreePerPlayer,                between(2,3))
  892. #define        (kTreePerNeutral,                0)
  893.  
  894.  
  895. //////////////////////////////////////////////////////////////////////
  896. // forest definitions
  897. #define        (kForestFreeRadius,            8.0)
  898. #define        (kForestsPerPlayer,            1)
  899. #define        (kForestChaosLevel,            0.9)
  900. #define        (kMaxClumpsPerForest,              2)
  901.  
  902.  
  903. #elif Is10Players
  904. //////////////////////////////////////////////////////////////////////
  905. // 10 PLAYERS...
  906. //////////////////////////////////////////////////////////////////////
  907.  
  908. //////////////////////////////////////////////////////////////////////
  909. // terrain definitions
  910. #define        (kMinIntElevation,            -10)
  911. #define        (kMaxIntElevation,            10)
  912. #define        (kElevationScale,                0.99)
  913. #define        (kPercentLand,                Between(.84, .84))
  914. #define        (kWaterBorder,                0)
  915. #define        (kHeightMapChaos,                Between(8, 20))
  916.  
  917. #define        (kMinimumStartPositionToMapEdge    4)
  918. #define        (kOuterPushFromMapCenter        28)
  919. #define        (kInnerPushFromMapCenter         0)                                            
  920. //////////////////////////////////////////////////////////////////////
  921. // player definitions
  922. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  923. #define        (kPlayerInnerRadius,            0.7)
  924. #define        (kPlayerOuterRadius,            0.99)
  925. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  926. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  927. #define        (kPlayerLandChaos,            0.8)
  928. #define        (kPlayerLandClumps,            1)
  929. #define        (kPlayerFlatChaos,            0.8)
  930. #define        (kPlayerFlatClumps,            2)
  931. #define        (kPlayerTreePercentage,            0.1)
  932.  
  933.  
  934. //////////////////////////////////////////////////////////////////////
  935. // inner neutral definitions
  936. #define        (kNeutralInnerRadius,            0.45)
  937. #define        (kNeutralOuterRadius,            0.45)
  938. #define        (kNeutralOptimalFactor,            0.7)
  939. #define        (kNumInnerNeutrals,            Between(3, 3))
  940. #define        (kInnerNeutralPercentLand,        0.1)
  941. #define        (kInnerNeutralPercentFlat,        0.8)
  942. #define        (kInnerNeutralTreePercentage,          0.2)
  943. #define        (kInnerNeutralLandChaos,        0.9)
  944. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  945. #define        (kInnerNeutralFlatChaos,        0.8)
  946. #define        (kInnerNeutralFlatClumps,        1)
  947.  
  948.  
  949. //////////////////////////////////////////////////////////////////////
  950. // outer neutral definitions
  951. #define        (kNumOuterNeutrals,            22)
  952. #define        (kOuterNeutralPercentLand,        0.45)
  953. #define        (kOuterNeutralPercentFlat,        0.8)
  954. #define        (kOuterNeutralTreePercentage,          0.2)
  955. #define        (kOuterNeutralLandChaos,        0.8)
  956. #define        (kOuterNeutralLandClumps,        2)
  957. #define        (kOuterNeutralFlatChaos,        0.8)
  958. #define        (kOuterNeutralFlatClumps,        1)
  959.  
  960.  
  961. //////////////////////////////////////////////////////////////////////
  962. // resource definitions
  963. #define        (kMaxResourceElevation,            3)
  964. #define        (kResourceToEdgeDistance,        1)
  965. #define        (kResourceToWaterDistance,        1)
  966.  
  967. #define        (kAnimalPerPlayer,            0)
  968. #define        (kAnimalPerNeutral,            0)
  969.  
  970. #define        (kBerryPerPlayer,                1)
  971. #define        (kBerryPerNeutral,            0)
  972.  
  973. #define        (kFishPerPlayer,                0)
  974. #define        (kFishPerNeutral,                45)
  975.  
  976. #define        (kGoldPerPlayer,                2)
  977. #define        (kGoldPerNeutral,                0)
  978.  
  979. #define        (kOilPerPlayer,                0)
  980. #define        (kOilPerNeutral,                0)
  981.  
  982. #define        (kSteelPerPlayer,                2)
  983. #define        (kSteelPerNeutral,            0)
  984.  
  985. #define        (kStonePerPlayer,                1)
  986. #define        (kStonePerNeutral,            5)
  987.  
  988. #define        (kTreePerPlayer,                between(2,3))
  989. #define        (kTreePerNeutral,                0)
  990.  
  991.  
  992. //////////////////////////////////////////////////////////////////////
  993. // forest definitions
  994. #define        (kForestFreeRadius,            8.0)
  995. #define        (kForestsPerPlayer,            1)
  996. #define        (kForestChaosLevel,            0.9)
  997. #define        (kMaxClumpsPerForest,              2)
  998.  
  999.  
  1000. #elif Is11Players
  1001. //////////////////////////////////////////////////////////////////////
  1002. // 11 PLAYERS...
  1003. //////////////////////////////////////////////////////////////////////
  1004.  
  1005. //////////////////////////////////////////////////////////////////////
  1006. // terrain definitions
  1007. #define        (kMinIntElevation,            -10)
  1008. #define        (kMaxIntElevation,            10)
  1009. #define        (kElevationScale,                0.99)
  1010. #define        (kPercentLand,                Between(.84, .84))
  1011. #define        (kWaterBorder,                0)
  1012. #define        (kHeightMapChaos,                Between(8, 20))
  1013.  
  1014. #define        (kMinimumStartPositionToMapEdge    4)
  1015. #define        (kOuterPushFromMapCenter        28)
  1016. #define        (kInnerPushFromMapCenter         0)                                            
  1017. //////////////////////////////////////////////////////////////////////
  1018. // player definitions
  1019. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1020. #define        (kPlayerInnerRadius,            0.7)
  1021. #define        (kPlayerOuterRadius,            0.99)
  1022. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1023. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1024. #define        (kPlayerLandChaos,            0.8)
  1025. #define        (kPlayerLandClumps,            1)
  1026. #define        (kPlayerFlatChaos,            0.8)
  1027. #define        (kPlayerFlatClumps,            2)
  1028. #define        (kPlayerTreePercentage,            0.1)
  1029.  
  1030.  
  1031. //////////////////////////////////////////////////////////////////////
  1032. // inner neutral definitions
  1033. #define        (kNeutralInnerRadius,            0.45)
  1034. #define        (kNeutralOuterRadius,            0.45)
  1035. #define        (kNeutralOptimalFactor,            0.7)
  1036. #define        (kNumInnerNeutrals,            Between(3, 3))
  1037. #define        (kInnerNeutralPercentLand,        0.1)
  1038. #define        (kInnerNeutralPercentFlat,        0.8)
  1039. #define        (kInnerNeutralTreePercentage,          0.2)
  1040. #define        (kInnerNeutralLandChaos,        0.9)
  1041. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1042. #define        (kInnerNeutralFlatChaos,        0.8)
  1043. #define        (kInnerNeutralFlatClumps,        1)
  1044.  
  1045.  
  1046. //////////////////////////////////////////////////////////////////////
  1047. // outer neutral definitions
  1048. #define        (kNumOuterNeutrals,            22)
  1049. #define        (kOuterNeutralPercentLand,        0.45)
  1050. #define        (kOuterNeutralPercentFlat,        0.8)
  1051. #define        (kOuterNeutralTreePercentage,          0.2)
  1052. #define        (kOuterNeutralLandChaos,        0.8)
  1053. #define        (kOuterNeutralLandClumps,        2)
  1054. #define        (kOuterNeutralFlatChaos,        0.8)
  1055. #define        (kOuterNeutralFlatClumps,        1)
  1056.  
  1057.  
  1058. //////////////////////////////////////////////////////////////////////
  1059. // resource definitions
  1060. #define        (kMaxResourceElevation,            3)
  1061. #define        (kResourceToEdgeDistance,        1)
  1062. #define        (kResourceToWaterDistance,        1)
  1063.  
  1064. #define        (kAnimalPerPlayer,            0)
  1065. #define        (kAnimalPerNeutral,            0)
  1066.  
  1067. #define        (kBerryPerPlayer,                1)
  1068. #define        (kBerryPerNeutral,            0)
  1069.  
  1070. #define        (kFishPerPlayer,                0)
  1071. #define        (kFishPerNeutral,                45)
  1072.  
  1073. #define        (kGoldPerPlayer,                2)
  1074. #define        (kGoldPerNeutral,                0)
  1075.  
  1076. #define        (kOilPerPlayer,                0)
  1077. #define        (kOilPerNeutral,                0)
  1078.  
  1079. #define        (kSteelPerPlayer,                2)
  1080. #define        (kSteelPerNeutral,            0)
  1081.  
  1082. #define        (kStonePerPlayer,                1)
  1083. #define        (kStonePerNeutral,            5)
  1084.  
  1085. #define        (kTreePerPlayer,                between(2,3))
  1086. #define        (kTreePerNeutral,                0)
  1087.  
  1088.  
  1089. //////////////////////////////////////////////////////////////////////
  1090. // forest definitions
  1091. #define        (kForestFreeRadius,            8.0)
  1092. #define        (kForestsPerPlayer,            1)
  1093. #define        (kForestChaosLevel,            0.9)
  1094. #define        (kMaxClumpsPerForest,              2)
  1095.  
  1096.  
  1097. #elif Is12Players
  1098. //////////////////////////////////////////////////////////////////////
  1099. // 12 PLAYERS...
  1100. //////////////////////////////////////////////////////////////////////
  1101.  
  1102. //////////////////////////////////////////////////////////////////////
  1103. // terrain definitions
  1104. #define        (kMinIntElevation,            -10)
  1105. #define        (kMaxIntElevation,            10)
  1106. #define        (kElevationScale,                0.99)
  1107. #define        (kPercentLand,                Between(.84, .84))
  1108. #define        (kWaterBorder,                0)
  1109. #define        (kHeightMapChaos,                Between(8, 20))
  1110.  
  1111. #define        (kMinimumStartPositionToMapEdge    4)
  1112. #define        (kOuterPushFromMapCenter        28)
  1113. #define        (kInnerPushFromMapCenter         0)                                            
  1114. //////////////////////////////////////////////////////////////////////
  1115. // player definitions
  1116. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1117. #define        (kPlayerInnerRadius,            0.7)
  1118. #define        (kPlayerOuterRadius,            0.99)
  1119. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1120. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1121. #define        (kPlayerLandChaos,            0.8)
  1122. #define        (kPlayerLandClumps,            1)
  1123. #define        (kPlayerFlatChaos,            0.8)
  1124. #define        (kPlayerFlatClumps,            2)
  1125. #define        (kPlayerTreePercentage,            0.1)
  1126.  
  1127.  
  1128. //////////////////////////////////////////////////////////////////////
  1129. // inner neutral definitions
  1130. #define        (kNeutralInnerRadius,            0.45)
  1131. #define        (kNeutralOuterRadius,            0.45)
  1132. #define        (kNeutralOptimalFactor,            0.7)
  1133. #define        (kNumInnerNeutrals,            Between(3, 3))
  1134. #define        (kInnerNeutralPercentLand,        0.1)
  1135. #define        (kInnerNeutralPercentFlat,        0.8)
  1136. #define        (kInnerNeutralTreePercentage,          0.2)
  1137. #define        (kInnerNeutralLandChaos,        0.9)
  1138. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1139. #define        (kInnerNeutralFlatChaos,        0.8)
  1140. #define        (kInnerNeutralFlatClumps,        1)
  1141.  
  1142.  
  1143. //////////////////////////////////////////////////////////////////////
  1144. // outer neutral definitions
  1145. #define        (kNumOuterNeutrals,            22)
  1146. #define        (kOuterNeutralPercentLand,        0.45)
  1147. #define        (kOuterNeutralPercentFlat,        0.8)
  1148. #define        (kOuterNeutralTreePercentage,          0.2)
  1149. #define        (kOuterNeutralLandChaos,        0.8)
  1150. #define        (kOuterNeutralLandClumps,        2)
  1151. #define        (kOuterNeutralFlatChaos,        0.8)
  1152. #define        (kOuterNeutralFlatClumps,        1)
  1153.  
  1154.  
  1155. //////////////////////////////////////////////////////////////////////
  1156. // resource definitions
  1157. #define        (kMaxResourceElevation,            3)
  1158. #define        (kResourceToEdgeDistance,        1)
  1159. #define        (kResourceToWaterDistance,        1)
  1160.  
  1161. #define        (kAnimalPerPlayer,            0)
  1162. #define        (kAnimalPerNeutral,            0)
  1163.  
  1164. #define        (kBerryPerPlayer,                1)
  1165. #define        (kBerryPerNeutral,            0)
  1166.  
  1167. #define        (kFishPerPlayer,                0)
  1168. #define        (kFishPerNeutral,                45)
  1169.  
  1170. #define        (kGoldPerPlayer,                2)
  1171. #define        (kGoldPerNeutral,                0)
  1172.  
  1173. #define        (kOilPerPlayer,                0)
  1174. #define        (kOilPerNeutral,                0)
  1175.  
  1176. #define        (kSteelPerPlayer,                2)
  1177. #define        (kSteelPerNeutral,            0)
  1178.  
  1179. #define        (kStonePerPlayer,                1)
  1180. #define        (kStonePerNeutral,            5)
  1181.  
  1182. #define        (kTreePerPlayer,                between(2,3))
  1183. #define        (kTreePerNeutral,                0)
  1184.  
  1185.  
  1186. //////////////////////////////////////////////////////////////////////
  1187. // forest definitions
  1188. #define        (kForestFreeRadius,            8.0)
  1189. #define        (kForestsPerPlayer,            1)
  1190. #define        (kForestChaosLevel,            0.9)
  1191. #define        (kMaxClumpsPerForest,              2)
  1192.  
  1193.  
  1194. #elif Is13Players
  1195. //////////////////////////////////////////////////////////////////////
  1196. // 13 PLAYERS...
  1197. //////////////////////////////////////////////////////////////////////
  1198.  
  1199. //////////////////////////////////////////////////////////////////////
  1200. // terrain definitions
  1201. #define        (kMinIntElevation,            -10)
  1202. #define        (kMaxIntElevation,            10)
  1203. #define        (kElevationScale,                0.99)
  1204. #define        (kPercentLand,                Between(.84, .84))
  1205. #define        (kWaterBorder,                0)
  1206. #define        (kHeightMapChaos,                Between(8, 20))
  1207.  
  1208. #define        (kMinimumStartPositionToMapEdge    4)
  1209. #define        (kOuterPushFromMapCenter        28)
  1210. #define        (kInnerPushFromMapCenter         0)                                            
  1211. //////////////////////////////////////////////////////////////////////
  1212. // player definitions
  1213. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1214. #define        (kPlayerInnerRadius,            0.7)
  1215. #define        (kPlayerOuterRadius,            0.99)
  1216. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1217. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1218. #define        (kPlayerLandChaos,            0.8)
  1219. #define        (kPlayerLandClumps,            1)
  1220. #define        (kPlayerFlatChaos,            0.8)
  1221. #define        (kPlayerFlatClumps,            2)
  1222. #define        (kPlayerTreePercentage,            0.1)
  1223.  
  1224.  
  1225. //////////////////////////////////////////////////////////////////////
  1226. // inner neutral definitions
  1227. #define        (kNeutralInnerRadius,            0.45)
  1228. #define        (kNeutralOuterRadius,            0.45)
  1229. #define        (kNeutralOptimalFactor,            0.7)
  1230. #define        (kNumInnerNeutrals,            Between(3, 3))
  1231. #define        (kInnerNeutralPercentLand,        0.1)
  1232. #define        (kInnerNeutralPercentFlat,        0.8)
  1233. #define        (kInnerNeutralTreePercentage,          0.2)
  1234. #define        (kInnerNeutralLandChaos,        0.9)
  1235. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1236. #define        (kInnerNeutralFlatChaos,        0.8)
  1237. #define        (kInnerNeutralFlatClumps,        1)
  1238.  
  1239.  
  1240. //////////////////////////////////////////////////////////////////////
  1241. // outer neutral definitions
  1242. #define        (kNumOuterNeutrals,            22)
  1243. #define        (kOuterNeutralPercentLand,        0.45)
  1244. #define        (kOuterNeutralPercentFlat,        0.8)
  1245. #define        (kOuterNeutralTreePercentage,          0.2)
  1246. #define        (kOuterNeutralLandChaos,        0.8)
  1247. #define        (kOuterNeutralLandClumps,        2)
  1248. #define        (kOuterNeutralFlatChaos,        0.8)
  1249. #define        (kOuterNeutralFlatClumps,        1)
  1250.  
  1251.  
  1252. //////////////////////////////////////////////////////////////////////
  1253. // resource definitions
  1254. #define        (kMaxResourceElevation,            3)
  1255. #define        (kResourceToEdgeDistance,        1)
  1256. #define        (kResourceToWaterDistance,        1)
  1257.  
  1258. #define        (kAnimalPerPlayer,            0)
  1259. #define        (kAnimalPerNeutral,            0)
  1260.  
  1261. #define        (kBerryPerPlayer,                1)
  1262. #define        (kBerryPerNeutral,            0)
  1263.  
  1264. #define        (kFishPerPlayer,                0)
  1265. #define        (kFishPerNeutral,                45)
  1266.  
  1267. #define        (kGoldPerPlayer,                2)
  1268. #define        (kGoldPerNeutral,                0)
  1269.  
  1270. #define        (kOilPerPlayer,                0)
  1271. #define        (kOilPerNeutral,                0)
  1272.  
  1273. #define        (kSteelPerPlayer,                2)
  1274. #define        (kSteelPerNeutral,            0)
  1275.  
  1276. #define        (kStonePerPlayer,                1)
  1277. #define        (kStonePerNeutral,            5)
  1278.  
  1279. #define        (kTreePerPlayer,                between(2,3))
  1280. #define        (kTreePerNeutral,                0)
  1281.  
  1282.  
  1283. //////////////////////////////////////////////////////////////////////
  1284. // forest definitions
  1285. #define        (kForestFreeRadius,            8.0)
  1286. #define        (kForestsPerPlayer,            1)
  1287. #define        (kForestChaosLevel,            0.9)
  1288. #define        (kMaxClumpsPerForest,              2)
  1289.  
  1290.  
  1291. #elif Is14Players
  1292. //////////////////////////////////////////////////////////////////////
  1293. // 14 PLAYERS...
  1294. //////////////////////////////////////////////////////////////////////
  1295.  
  1296. //////////////////////////////////////////////////////////////////////
  1297. // terrain definitions
  1298. #define        (kMinIntElevation,            -10)
  1299. #define        (kMaxIntElevation,            10)
  1300. #define        (kElevationScale,                0.99)
  1301. #define        (kPercentLand,                Between(.84, .84))
  1302. #define        (kWaterBorder,                0)
  1303. #define        (kHeightMapChaos,                Between(8, 20))
  1304.  
  1305. #define        (kMinimumStartPositionToMapEdge    4)
  1306. #define        (kOuterPushFromMapCenter        28)
  1307. #define        (kInnerPushFromMapCenter         0)                                            
  1308. //////////////////////////////////////////////////////////////////////
  1309. // player definitions
  1310. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1311. #define        (kPlayerInnerRadius,            0.7)
  1312. #define        (kPlayerOuterRadius,            0.99)
  1313. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1314. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1315. #define        (kPlayerLandChaos,            0.8)
  1316. #define        (kPlayerLandClumps,            1)
  1317. #define        (kPlayerFlatChaos,            0.8)
  1318. #define        (kPlayerFlatClumps,            2)
  1319. #define        (kPlayerTreePercentage,            0.1)
  1320.  
  1321.  
  1322. //////////////////////////////////////////////////////////////////////
  1323. // inner neutral definitions
  1324. #define        (kNeutralInnerRadius,            0.45)
  1325. #define        (kNeutralOuterRadius,            0.45)
  1326. #define        (kNeutralOptimalFactor,            0.7)
  1327. #define        (kNumInnerNeutrals,            Between(3, 3))
  1328. #define        (kInnerNeutralPercentLand,        0.1)
  1329. #define        (kInnerNeutralPercentFlat,        0.8)
  1330. #define        (kInnerNeutralTreePercentage,          0.2)
  1331. #define        (kInnerNeutralLandChaos,        0.9)
  1332. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1333. #define        (kInnerNeutralFlatChaos,        0.8)
  1334. #define        (kInnerNeutralFlatClumps,        1)
  1335.  
  1336.  
  1337. //////////////////////////////////////////////////////////////////////
  1338. // outer neutral definitions
  1339. #define        (kNumOuterNeutrals,            22)
  1340. #define        (kOuterNeutralPercentLand,        0.45)
  1341. #define        (kOuterNeutralPercentFlat,        0.8)
  1342. #define        (kOuterNeutralTreePercentage,          0.2)
  1343. #define        (kOuterNeutralLandChaos,        0.8)
  1344. #define        (kOuterNeutralLandClumps,        2)
  1345. #define        (kOuterNeutralFlatChaos,        0.8)
  1346. #define        (kOuterNeutralFlatClumps,        1)
  1347.  
  1348.  
  1349. //////////////////////////////////////////////////////////////////////
  1350. // resource definitions
  1351. #define        (kMaxResourceElevation,            3)
  1352. #define        (kResourceToEdgeDistance,        1)
  1353. #define        (kResourceToWaterDistance,        1)
  1354.  
  1355. #define        (kAnimalPerPlayer,            0)
  1356. #define        (kAnimalPerNeutral,            0)
  1357.  
  1358. #define        (kBerryPerPlayer,                1)
  1359. #define        (kBerryPerNeutral,            0)
  1360.  
  1361. #define        (kFishPerPlayer,                0)
  1362. #define        (kFishPerNeutral,                45)
  1363.  
  1364. #define        (kGoldPerPlayer,                2)
  1365. #define        (kGoldPerNeutral,                0)
  1366.  
  1367. #define        (kOilPerPlayer,                0)
  1368. #define        (kOilPerNeutral,                0)
  1369.  
  1370. #define        (kSteelPerPlayer,                2)
  1371. #define        (kSteelPerNeutral,            0)
  1372.  
  1373. #define        (kStonePerPlayer,                1)
  1374. #define        (kStonePerNeutral,            5)
  1375.  
  1376. #define        (kTreePerPlayer,                between(2,3))
  1377. #define        (kTreePerNeutral,                0)
  1378.  
  1379.  
  1380. //////////////////////////////////////////////////////////////////////
  1381. // forest definitions
  1382. #define        (kForestFreeRadius,            8.0)
  1383. #define        (kForestsPerPlayer,            1)
  1384. #define        (kForestChaosLevel,            0.9)
  1385. #define        (kMaxClumpsPerForest,              2)
  1386.  
  1387.  
  1388. #elif Is15Players
  1389. //////////////////////////////////////////////////////////////////////
  1390. // 15 PLAYERS...
  1391. //////////////////////////////////////////////////////////////////////
  1392.  
  1393. //////////////////////////////////////////////////////////////////////
  1394. // terrain definitions
  1395. #define        (kMinIntElevation,            -10)
  1396. #define        (kMaxIntElevation,            10)
  1397. #define        (kElevationScale,                0.99)
  1398. #define        (kPercentLand,                Between(.84, .84))
  1399. #define        (kWaterBorder,                0)
  1400. #define        (kHeightMapChaos,                Between(8, 20))
  1401.  
  1402. #define        (kMinimumStartPositionToMapEdge    4)
  1403. #define        (kOuterPushFromMapCenter        28)
  1404. #define        (kInnerPushFromMapCenter         0)                                            
  1405. //////////////////////////////////////////////////////////////////////
  1406. // player definitions
  1407. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1408. #define        (kPlayerInnerRadius,            0.7)
  1409. #define        (kPlayerOuterRadius,            0.99)
  1410. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1411. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1412. #define        (kPlayerLandChaos,            0.8)
  1413. #define        (kPlayerLandClumps,            1)
  1414. #define        (kPlayerFlatChaos,            0.8)
  1415. #define        (kPlayerFlatClumps,            2)
  1416. #define        (kPlayerTreePercentage,            0.1)
  1417.  
  1418.  
  1419. //////////////////////////////////////////////////////////////////////
  1420. // inner neutral definitions
  1421. #define        (kNeutralInnerRadius,            0.45)
  1422. #define        (kNeutralOuterRadius,            0.45)
  1423. #define        (kNeutralOptimalFactor,            0.7)
  1424. #define        (kNumInnerNeutrals,            Between(3, 3))
  1425. #define        (kInnerNeutralPercentLand,        0.1)
  1426. #define        (kInnerNeutralPercentFlat,        0.8)
  1427. #define        (kInnerNeutralTreePercentage,          0.2)
  1428. #define        (kInnerNeutralLandChaos,        0.9)
  1429. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1430. #define        (kInnerNeutralFlatChaos,        0.8)
  1431. #define        (kInnerNeutralFlatClumps,        1)
  1432.  
  1433.  
  1434. //////////////////////////////////////////////////////////////////////
  1435. // outer neutral definitions
  1436. #define        (kNumOuterNeutrals,            22)
  1437. #define        (kOuterNeutralPercentLand,        0.45)
  1438. #define        (kOuterNeutralPercentFlat,        0.8)
  1439. #define        (kOuterNeutralTreePercentage,          0.2)
  1440. #define        (kOuterNeutralLandChaos,        0.8)
  1441. #define        (kOuterNeutralLandClumps,        2)
  1442. #define        (kOuterNeutralFlatChaos,        0.8)
  1443. #define        (kOuterNeutralFlatClumps,        1)
  1444.  
  1445.  
  1446. //////////////////////////////////////////////////////////////////////
  1447. // resource definitions
  1448. #define        (kMaxResourceElevation,            3)
  1449. #define        (kResourceToEdgeDistance,        1)
  1450. #define        (kResourceToWaterDistance,        1)
  1451.  
  1452. #define        (kAnimalPerPlayer,            0)
  1453. #define        (kAnimalPerNeutral,            0)
  1454.  
  1455. #define        (kBerryPerPlayer,                1)
  1456. #define        (kBerryPerNeutral,            0)
  1457.  
  1458. #define        (kFishPerPlayer,                0)
  1459. #define        (kFishPerNeutral,                45)
  1460.  
  1461. #define        (kGoldPerPlayer,                2)
  1462. #define        (kGoldPerNeutral,                0)
  1463.  
  1464. #define        (kOilPerPlayer,                0)
  1465. #define        (kOilPerNeutral,                0)
  1466.  
  1467. #define        (kSteelPerPlayer,                2)
  1468. #define        (kSteelPerNeutral,            0)
  1469.  
  1470. #define        (kStonePerPlayer,                1)
  1471. #define        (kStonePerNeutral,            5)
  1472.  
  1473. #define        (kTreePerPlayer,                between(2,3))
  1474. #define        (kTreePerNeutral,                0)
  1475.  
  1476.  
  1477. //////////////////////////////////////////////////////////////////////
  1478. // forest definitions
  1479. #define        (kForestFreeRadius,            8.0)
  1480. #define        (kForestsPerPlayer,            1)
  1481. #define        (kForestChaosLevel,            0.9)
  1482. #define        (kMaxClumpsPerForest,              2)
  1483.  
  1484.  
  1485. #elif Is16Players
  1486. //////////////////////////////////////////////////////////////////////
  1487. // 16 PLAYERS...
  1488. //////////////////////////////////////////////////////////////////////
  1489.  
  1490. //////////////////////////////////////////////////////////////////////
  1491. // terrain definitions
  1492. #define        (kMinIntElevation,            -10)
  1493. #define        (kMaxIntElevation,            10)
  1494. #define        (kElevationScale,                0.99)
  1495. #define        (kPercentLand,                Between(.84, .84))
  1496. #define        (kWaterBorder,                0)
  1497. #define        (kHeightMapChaos,                Between(8, 20))
  1498.  
  1499. #define        (kMinimumStartPositionToMapEdge    4)
  1500. #define        (kOuterPushFromMapCenter        28)
  1501. #define        (kInnerPushFromMapCenter         0)                                            
  1502. //////////////////////////////////////////////////////////////////////
  1503. // player definitions
  1504. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1505. #define        (kPlayerInnerRadius,            0.7)
  1506. #define        (kPlayerOuterRadius,            0.99)
  1507. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1508. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1509. #define        (kPlayerLandChaos,            0.8)
  1510. #define        (kPlayerLandClumps,            1)
  1511. #define        (kPlayerFlatChaos,            0.8)
  1512. #define        (kPlayerFlatClumps,            2)
  1513. #define        (kPlayerTreePercentage,            0.1)
  1514.  
  1515.  
  1516. //////////////////////////////////////////////////////////////////////
  1517. // inner neutral definitions
  1518. #define        (kNeutralInnerRadius,            0.45)
  1519. #define        (kNeutralOuterRadius,            0.45)
  1520. #define        (kNeutralOptimalFactor,            0.7)
  1521. #define        (kNumInnerNeutrals,            Between(3, 3))
  1522. #define        (kInnerNeutralPercentLand,        0.1)
  1523. #define        (kInnerNeutralPercentFlat,        0.8)
  1524. #define        (kInnerNeutralTreePercentage,          0.2)
  1525. #define        (kInnerNeutralLandChaos,        0.9)
  1526. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1527. #define        (kInnerNeutralFlatChaos,        0.8)
  1528. #define        (kInnerNeutralFlatClumps,        1)
  1529.  
  1530.  
  1531. //////////////////////////////////////////////////////////////////////
  1532. // outer neutral definitions
  1533. #define        (kNumOuterNeutrals,            22)
  1534. #define        (kOuterNeutralPercentLand,        0.45)
  1535. #define        (kOuterNeutralPercentFlat,        0.8)
  1536. #define        (kOuterNeutralTreePercentage,          0.2)
  1537. #define        (kOuterNeutralLandChaos,        0.8)
  1538. #define        (kOuterNeutralLandClumps,        2)
  1539. #define        (kOuterNeutralFlatChaos,        0.8)
  1540. #define        (kOuterNeutralFlatClumps,        1)
  1541.  
  1542.  
  1543. //////////////////////////////////////////////////////////////////////
  1544. // resource definitions
  1545. #define        (kMaxResourceElevation,            3)
  1546. #define        (kResourceToEdgeDistance,        1)
  1547. #define        (kResourceToWaterDistance,        1)
  1548.  
  1549. #define        (kAnimalPerPlayer,            0)
  1550. #define        (kAnimalPerNeutral,            0)
  1551.  
  1552. #define        (kBerryPerPlayer,                1)
  1553. #define        (kBerryPerNeutral,            0)
  1554.  
  1555. #define        (kFishPerPlayer,                0)
  1556. #define        (kFishPerNeutral,                45)
  1557.  
  1558. #define        (kGoldPerPlayer,                2)
  1559. #define        (kGoldPerNeutral,                0)
  1560.  
  1561. #define        (kOilPerPlayer,                0)
  1562. #define        (kOilPerNeutral,                0)
  1563.  
  1564. #define        (kSteelPerPlayer,                2)
  1565. #define        (kSteelPerNeutral,            0)
  1566.  
  1567. #define        (kStonePerPlayer,                1)
  1568. #define        (kStonePerNeutral,            5)
  1569.  
  1570. #define        (kTreePerPlayer,                between(2,3))
  1571. #define        (kTreePerNeutral,                0)
  1572.  
  1573.  
  1574. //////////////////////////////////////////////////////////////////////
  1575. // forest definitions
  1576. #define        (kForestFreeRadius,            8.0)
  1577. #define        (kForestsPerPlayer,            1)
  1578. #define        (kForestChaosLevel,            0.9)
  1579. #define        (kMaxClumpsPerForest,              2)
  1580.  
  1581.  
  1582. //////////////////////////////////////////////////////////////////////
  1583. // End of if...elif... command
  1584. #endif
  1585.  
  1586.  
  1587. #endif        // NOTDEFINED(CONTINENTAL_GIGANTIC_RMV)